package com.gxa.yaofang.service.impl;

import com.gxa.yaofang.mapper.YaoFangMapper;
import com.gxa.yaofang.mapper.YaoKuMapper;
import com.gxa.yaofang.pojo.YaoFang;
import com.gxa.yaofang.pojo.YaoKu;
import com.gxa.yaofang.util.POIUtil;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import com.gxa.yaofang.service.YaoKuService;
import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * (YaoKu)表服务实现类
 *
 * @author makejava
 * @since 2021-03-17 15:15:37
 * @version 1.0
 */
@Service("yaoKuService")
public class YaoKuServiceImpl implements YaoKuService {
    @Resource
    private YaoKuMapper yaoKuMapper;
    @Resource
    private YaoFangMapper YaofangMapper;
    @Resource
    private RedisTemplate redisTemplate;

    /**
     * 根据模糊条件查询总个数
     *
     * @return 返回查询到的总个数
     */
	@Override
    public Map<String, Object> chaXunCount(String mingCheng) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("list", this.yaoKuMapper.chaXunCount(mingCheng));
        return map;
    }

    /**
     * 查询所有数据
     * @return  返回所有数据
     */
	@Override
    public Map<String, Object> chaXunAll() {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("list", this.yaoKuMapper.chaXunAll());
        return map;
    }

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
	@Override
    public Map<String, Object> chaXunById(Integer id) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("obj", this.yaoKuMapper.chaXunById(id));
        return map;
    }

    /**
     * 查询分页数据
     *
     * @param page 查询起始位置
     * @param mingCheng 查询条数
     * @return 对象列表
     */
	@Override
    public Map<String, Object> chaXunFenYe(int page, String mingCheng) {
    // 获取当前表中的总记录
        int tableCount = this.yaoKuMapper.chaXunCount(mingCheng);
        // 总页码计算   (总条数 - 1) / 每页显示条数  + 1
        // (100 - 1) / 10 + 1 = 10        (101 - 1) / 10 + 1 = 11      (99 - 1) / 10 + 1 = 10
        int pageCount = (tableCount - 1) / 10 + 1;
        // 计算每页开始的下标值
        int xiaBiao = (page - 1) * 10;
        Map<String, Object> map = new HashMap<>();
        map.put("code", 0);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "查询成功");
        map.put("pageCount", pageCount);  // 查询的记录总页码
        map.put("count", tableCount);     // 当前表中的总条数
        map.put("data", this.yaoKuMapper.chaXunFenYe(xiaBiao, mingCheng));
        return map;
    }

    /**
     * 新增数据
     *
     * @param yaoKu 实例对象
     * @return 实例对象
     */
	@Override
    public Map<String, Object> xinZeng(YaoKu yaoKu) {
        // UUID.randomUUID()  返回内容：asd21321-ewrewrew213213-123213zsad-123asdasd这样的形态
        this.yaoKuMapper.xinZeng(yaoKu);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "新增成功");
        return map;
    }
    /**
     * 根据id调入药房数量
     *
     *
     * @return 实例对象
     */
    @Override
    public Map<String, Object> jinHuoById(int id, int jinHuoShuLiang) {
        this.yaoKuMapper.jinHuoById(id,jinHuoShuLiang);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "进货成功");
        return map;
    }
    /**
     * 通过ID查询单条数据
     *
     * @param yaoKu 实例对象
     * @return 实例对象
     */
	@Override
    public Map<String, Object> gengXinById(YaoKu yaoKu) {
        this.yaoKuMapper.gengXinById(yaoKu);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "更新成功");
        return map;
    }


    /**
     * 根据id调入药房数量
     *
     *
     * @return 实例对象
     */
    @Override
    public Map<String, Object> diaoRuYaoFangById(int id, int diaoRuYaoFangShuLiang,int yaoPinShuLiang) {
        if(yaoPinShuLiang<diaoRuYaoFangShuLiang){
            Map<String, Object> map = new HashMap<>();
            map.put("code", 100000);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
            map.put("msg", "药库库存不足");
            return map;
        }
        this.yaoKuMapper.diaoRuYaoFangById(id,diaoRuYaoFangShuLiang,yaoPinShuLiang);
        this.YaofangMapper.diaoRuById(id,diaoRuYaoFangShuLiang);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "已调出药库");
        return map;
    }
    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
	@Override
    public Map<String, Object> shanChuById(String id) {
        this.yaoKuMapper.shanChuById(id);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "删除成功");
        return map;
    }

    public void xiaZaiMuBan(HttpServletResponse response, List<Integer> ids) throws IOException {
        List<List<String>> arrayList_outer = new ArrayList<>();
        List<String> arrayList_inner = new ArrayList<>();
        arrayList_inner.add("药品名称");
        arrayList_inner.add("操作员");
        arrayList_inner.add("药品剩余数量");
        arrayList_inner.add("药品分类");
        arrayList_outer.add(arrayList_inner);
        for (int i = 0; i <ids.size(); i++){
            YaoKu yaoKu = yaoKuMapper.xiaZaiById(ids.get(i));
            arrayList_inner = new ArrayList<>();
            arrayList_inner.add(yaoKu.getYaoPinMingCheng());
            arrayList_inner.add(yaoKu.getCaoZuoYuan());
            arrayList_inner.add(yaoKu.getYaoPinShuLiang().toString());
            arrayList_inner.add(yaoKu.getYaoPinFenLei());
            arrayList_outer.add(arrayList_inner);
        }
        POIUtil poiUtil = new POIUtil();
        Workbook workbook = poiUtil.creatExcelForPOI(arrayList_outer, "第一页");

        if(workbook != null) {
            response.setCharacterEncoding("UTF-8");
            response.setHeader("Content-Disposition","attachment; filename=" + System.currentTimeMillis() + ".xls");
            //获取响应报文输出流对象
            ServletOutputStream out = response.getOutputStream();
            //输出
            workbook.write(out);
            out.flush();
            out.close();
        }
        else {
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().print("系统服务出错!");
        }
    }
    /**
     * 批量删除
     * @param
     * @return   返回删除状态信息
     */
    public Map<String, Object> deleteAll(String[] sids) {
        int sum = 0;
        for(String id : sids){
            int result = yaoKuMapper.shanChuById(id);
            sum += result;
        }
        if(sum==sids.length){
            Map<String, Object> map = new HashMap<>();
            map.put("code", 200);
            map.put("msg", "批量删除成功");
            return map;
        }
        else {
            Map<String, Object> map = new HashMap<>();
            map.put("code", 500);
            map.put("msg", "批量删除失败");
            return map;
        }
    }
}